package com.joke.util;

import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class StringUtil {
	
	/**
	 * 判断是否为null或空字符串
	 * 
	 * @param str
	 * @return
	 */
	public static boolean isEmpty(String str) {
		return str == null || str.trim().length() == 0;
	}

	/**
	 * 判断不为null且不为空字符串
	 * 
	 * @param str
	 * @return
	 */
	public static boolean isNotEmpty(String str) {
		return !isEmpty(str);
	}

	/**
	 * 执行trim操作
	 * 
	 * @param str
	 * @return
	 */
	public static String trim(String str) {
		if (str == null)
			return null;
		else
			return str.trim();
	}

	/**
	 * 比较两个字符串的字典顺序
	 * 
	 * @param str1
	 * @param str2
	 * @return 完全相等时返回0,str1>str2时返回正整数,str1<str2时返回负整数
	 */
	public static int compare(String str1, String str2) {
		if (str1 == null && str2 == null)
			return 0;
		if (str1 != null && str2 == null)
			return 1;
		if (str1 == null && str2 != null)
			return -1;
		return str1.compareTo(str2);
	}

	/**
	 * 判断两个字符串内容是否完全相同
	 * 
	 * @param str1
	 * @param str2
	 * @return
	 */
	public static boolean equals(String str1, String str2) {
		if (str1 == null && str2 == null)
			return true;
		if (str1 != null && str2 == null)
			return false;
		if (str1 == null && str2 != null)
			return false;
		return str1.equals(str2);
	}

	/**
	 * 替换src中的第1个str1为str2
	 * 
	 * @param src
	 * @param str1
	 * @param str2
	 * @return
	 */
	public static String replaceFirst(String src, String str1, String str2) {
		if (src == null || str1 == null)
			return src;
		StringBuffer ret = new StringBuffer();
		int pos = src.indexOf(str1);
		if (pos == 0) {
			ret.append(str2).append(src.substring(str1.length()));
		} else if (pos > 0) {
			ret.append(src.substring(0, pos)).append(str2).append(src.substring(pos + str1.length()));
		} else {
			ret.append(src);
		}
		return ret.toString();
	}

	/**
	 * 替换src中所有的str1为str2
	 * 
	 * @param src
	 * @param str1
	 * @param str2
	 * @return
	 */
	public static String replaceAll(String src, String str1, String str2) {
		String ret = src;
		do {
			src = ret;
			ret = replaceFirst(src, str1, str2);
		} while (ret != null && !ret.equals(src));
		return ret;
	}

	/**
	 * 将src中所有的str1都改成str2
	 * 
	 * @param src 源字符串
	 * @param str1 被替换的子串
	 * @param str2 要替换为的子串
	 * @return 修改后的字符串
	 */
	public static String replace(String src, String str1, String str2) {
		if (src == null || str1 == null)
			return src;
		StringBuffer strDest = new StringBuffer();
		int intFromLen = str1.length();
		int intPos;

		while (src != null && (intPos = src.indexOf(str1)) != -1) {
			strDest.append(src.substring(0, intPos));
			strDest.append(str2);
			src = src.substring(intPos + intFromLen);
		}
		strDest.append(src);

		return strDest.toString();
	}

	/**
	 * 判断是否为纯数字
	 * 
	 * @param str
	 * @return
	 */
	public static boolean isInt(String str) {
		if (isEmpty(str)) {
			return false;
		}
		Pattern p = Pattern.compile("(-?[0-9]+|[0-9]*)?");
		Matcher m = p.matcher(str);
		return m.matches();

	}

	/**
	 * 返回字符串的长度, 每个英文字符长度为1，中文字符长度为2，为空时返回-1
	 * 
	 * @param value
	 * @return
	 */
	public static int byteLen(String value) {
		if (value == null)
			return -1;
		int ret = 1;
		ret = value.getBytes().length;
		return ret;
	}

	/**
	 * 判断是否是GBK编码
	 * 
	 * @param tStr String
	 * @return boolean
	 */
	public static boolean isGBKString(String tStr) {
		int tlength = tStr.length();
		int t1 = 0;
		for (int i = 0; i < tlength; i++) {
			t1 = Integer.parseInt(Integer.toOctalString(tStr.charAt(i)));
			if (t1 > 511) {
				return true;
			}
		}
		return false;
	}

	/**
	 * 判断是否是Unicode编码
	 * 
	 * @param tStr String
	 * @return boolean
	 */
	public static boolean isUnicodeString(String tStr) {
		int tlength = tStr.length();
		int t1 = 0;
		for (int i = 0; i < tlength; i++) {
			t1 = Integer.parseInt(Integer.toOctalString(tStr.charAt(i)));
			if (t1 > 511) {
				return false;
			}
		}
		return true;
	}
	
	/**
	 * 将字符串转换为GBK字符串
	 * 
	 * @param strOriginal String 原串
	 * @return String 将原串由ISO8859_1(Unicode)编码转换为GBK编码
	 */
	public static String unicodeToGBK(String strOriginal) {
		if (strOriginal != null) {
			try {
				// 如果在这里不作任何处理，全部直接返回的话，会是什么现象？
				if (isGBKString(strOriginal)) {
					return strOriginal;
				} else {
					return new String(strOriginal.getBytes("ISO8859_1"), "GBK");
				}

			} catch (Exception e) {
				e.printStackTrace();
				return strOriginal;
			}
		} else {
			return "";
		}
	}

	/**
	 * 将字符串转换为Unicode字符串
	 * 
	 * @param strOriginal String 原串
	 * @return String 将原串由GBK编码转换为ISO8859_1(Unicode)编码
	 */
	public static String GBKToUnicode(String strOriginal) {
		if (strOriginal != null) {
			try {
				if (isGBKString(strOriginal)) {
					return new String(strOriginal.getBytes("GBK"), "ISO8859_1");
				} else {
					return strOriginal;
				}
			} catch (Exception e) {
				e.printStackTrace();
				return strOriginal;
			}
		} else {
			return null;
		}
	}
	
	/**
	 * 将字符串按照指定的分隔字符进行拆分,返回从指定序号的分隔符到前一个分隔符之间的字符串
	 * 
	 * @param strMain String 主字符串
	 * @param strDelimiters String 分隔符
	 * @param intSerialNo int 分隔符序号
	 * @return String 指定序号的分隔符到前一个分隔符之间的字符串,如果没有找到则返回"" 例如：值赋串类似于 值1|值2|值3|值4|
	 *         则intSerialNo=0 return "" intSerialNo=1 return "值1" intSerialNo=5
	 *         return ""
	 */
	public static String decodeStr(String strMain, String strDelimiters, int intSerialNo) {
		int intIndex = 0; /* 分隔符出现在主字符串中的起始位置 */
		int intCount = 0; /* 在扫描主字符串的过程中,第几次遇到分隔符字符串 */
		String strReturn = ""; /* 作为返回值的字符串 */

		if (strMain.length() < strDelimiters.length()) {
			return ""; /* 若主字符串比分隔符串还要短的话,则返回空字符串 */
		}

		intIndex = strMain.indexOf(strDelimiters);
		if (intIndex == -1) {
			return ""; /* 若主字符串中不存在分隔符,则返回空字符串 */
		}

		while (intIndex != -1) /* 未找到分隔符时退出循环,并返回空字符串 */
		{
			strReturn = strMain.substring(0, intIndex);
			intCount++;
			if (intCount == intSerialNo) {
				if (intIndex == 0) {
					return "";
				} else {
					return strReturn.trim();
				}
			}
			strMain = strMain.substring(intIndex + 1);
			intIndex = strMain.indexOf(strDelimiters);
		}
		return "";
	}

	/**
	 * 获取子串在主串中出现第 n 次的位置
	 * 
	 * @param strMain String 主字符串
	 * @param strSub String 子字符串
	 * @param intTimes int 出现次数
	 * @return int 位置值,如果子串在主串中没有出现指定次数,则返回-1
	 */
	public static int getPos(String strMain, String strSub, int intTimes) {
		int intCounter = 0; // 循环记数
		int intPosition = 0; // 位置记录
		int intLength = strSub.length(); // 子串长度

		if (intTimes <= 0) {
			return -1;
		}
		while (intCounter < intTimes) {
			intPosition = strMain.indexOf(strSub, intPosition);
			if (intPosition == -1) {
				return -1;
			}
			intCounter++;
			intPosition += intLength;
		}
		return intPosition - intLength;
	}

	/**
	 * 获取从指定位置开始子串在主串中出现第 n 次的位置
	 * 
	 * @param strMain String 主字符串
	 * @param strSub String 子字符串
	 * @param intStartIndex int 起始位置
	 * @param intTimes int 出现次数
	 * @return int 位置值,如果从起始位置起子串在主串中没有出现指定次数,则返回-1
	 */
	public static int getPos(String strMain, String strSub, int intStartIndex, int intTimes) {
		if (strMain.length() - 1 < intStartIndex) {
			return -1;
		}
		int intPosition = getPos(strMain.substring(intStartIndex), strSub, intTimes);
		if (intPosition != -1) {
			intPosition += intStartIndex;
		}
		return intPosition;
	}

	/**
	 * 数组转化为,分隔的字符串
	 * 
	 * @param arrays
	 * @return
	 */
	public static String arrayToString(Object[] arrays) {
		return arrayToString(arrays, ",");
	}

	/**
	 * 数组转化为symbol分隔字符串
	 */
	public static String arrayToString(Object[] arrays, String symbol) {
		return arrayToString(arrays, symbol, "");
	}

	/**
	 * 数组转化为symbol分隔且加引号的字符串
	 * 
	 * @param arrays
	 * @param symbol
	 * @param quote
	 * @return
	 */
	public static String arrayToString(Object[] arrays, String symbol, String quote) {
		if (arrays == null)
			return null;

		StringBuffer str = new StringBuffer();
		for (int i = 0, j = arrays.length; i < j; i++) {
			if (i > 0) {
				str.append(symbol);
			}
			if (isNotEmpty(quote)) {
				str.append(quote);
			}
			str.append(arrays[i]);
			if (isNotEmpty(quote)) {
				str.append(quote);
			}
		}
		return str.toString();
	}
	
	/**
	 * 数字大写
	 * 
	 * @param intValue int
	 * @return String
	 */
	public static String toUpper(int intValue) {
		String strOutValue = "";
		String[] strTemp = { "零", "壹", "贰", "叁", "肆", "伍", "陆", "柒", "捌", "玖" };
		try {
			strOutValue = strTemp[intValue];
		} catch (Exception exception) {
			strOutValue = "";
		}
		return strOutValue;
	}

	/**
	 * 得到单位
	 * 
	 * @param intValue int
	 * @return String
	 */
	public static String getUnit(int intValue) {
		String strOutValue = "";
		String[] strTemp = { "仟", "佰", "拾", "亿", "仟", "佰", "拾", "万", "仟", "佰", "拾", "", "", "" };

		try {
			strOutValue = strTemp[intValue];
		} catch (Exception exception) {
			strOutValue = "";
		}
		return strOutValue;
	}
	
	public static boolean check(String content) {
		if(!"".equals(content.trim())&&content.trim().length()<=800 && content.indexOf("匿") == -1
				&& content.trim().indexOf("糗百") == -1 && content.trim().indexOf("??????") == -1
				&& content.trim().indexOf("捧腹") == -1&& content.trim().indexOf("段友") == -1
				&& content.trim().indexOf("查看全文") == -1) {
			return true;
		}
		return false;
	}
	
	/**
	 * 去除emoji表情
	 * @param content
	 * @return
	 */
	public static String reSpecial(String content) {
		return content.trim().replace("", "").replace(Const.reSymbol, "")
				.replaceAll("[\\ud800\\udc00-\\udbff\\udfff\\ud800-\\udfff]", "");
	}
}
